home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / symtable.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  10KB  |  300 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import _symtable
  5. from _symtable import USE, DEF_GLOBAL, DEF_LOCAL, DEF_PARAM, DEF_STAR, DEF_DOUBLESTAR, DEF_INTUPLE, DEF_FREE, DEF_FREE_GLOBAL, DEF_FREE_CLASS, DEF_IMPORT, DEF_BOUND, OPT_IMPORT_STAR, OPT_EXEC, OPT_BARE_EXEC
  6. import weakref
  7. __all__ = [
  8.     'symtable',
  9.     'SymbolTable',
  10.     'newSymbolTable',
  11.     'Class',
  12.     'Function',
  13.     'Symbol']
  14.  
  15. def symtable(code, filename, compile_type):
  16.     raw = _symtable.symtable(code, filename, compile_type)
  17.     for top in raw.itervalues():
  18.         if top.name == 'top':
  19.             break
  20.             continue
  21.     
  22.     return newSymbolTable(top, filename)
  23.  
  24.  
  25. class SymbolTableFactory:
  26.     
  27.     def __init__(self):
  28.         self._SymbolTableFactory__memo = weakref.WeakValueDictionary()
  29.  
  30.     
  31.     def new(self, table, filename):
  32.         if table.type == _symtable.TYPE_FUNCTION:
  33.             return Function(table, filename)
  34.         
  35.         if table.type == _symtable.TYPE_CLASS:
  36.             return Class(table, filename)
  37.         
  38.         return SymbolTable(table, filename)
  39.  
  40.     
  41.     def __call__(self, table, filename):
  42.         key = (table, filename)
  43.         obj = self._SymbolTableFactory__memo.get(key, None)
  44.         if obj is None:
  45.             obj = self._SymbolTableFactory__memo[key] = self.new(table, filename)
  46.         
  47.         return obj
  48.  
  49.  
  50. newSymbolTable = SymbolTableFactory()
  51.  
  52. def is_free(flags):
  53.     if flags & (USE | DEF_FREE) and flags & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL):
  54.         return True
  55.     
  56.     if flags & DEF_FREE_CLASS:
  57.         return True
  58.     
  59.     return False
  60.  
  61.  
  62. class SymbolTable:
  63.     
  64.     def __init__(self, raw_table, filename):
  65.         self._table = raw_table
  66.         self._filename = filename
  67.         self._symbols = { }
  68.  
  69.     
  70.     def __repr__(self):
  71.         if self.__class__ == SymbolTable:
  72.             kind = ''
  73.         else:
  74.             kind = '%s ' % self.__class__.__name__
  75.         if self._table.name == 'global':
  76.             return '<%sSymbolTable for module %s>' % (kind, self._filename)
  77.         else:
  78.             return '<%sSymbolTable for %s in %s>' % (kind, self._table.name, self._filename)
  79.  
  80.     
  81.     def get_type(self):
  82.         if self._table.type == _symtable.TYPE_MODULE:
  83.             return 'module'
  84.         
  85.         if self._table.type == _symtable.TYPE_FUNCTION:
  86.             return 'function'
  87.         
  88.         if self._table.type == _symtable.TYPE_CLASS:
  89.             return 'class'
  90.         
  91.  
  92.     
  93.     def get_id(self):
  94.         return self._table.id
  95.  
  96.     
  97.     def get_name(self):
  98.         return self._table.name
  99.  
  100.     
  101.     def get_lineno(self):
  102.         return self._table.lineno
  103.  
  104.     
  105.     def is_optimized(self):
  106.         if self._table.type == _symtable.TYPE_FUNCTION:
  107.             pass
  108.         return bool(not (self._table.optimized))
  109.  
  110.     
  111.     def is_nested(self):
  112.         return bool(self._table.nested)
  113.  
  114.     
  115.     def has_children(self):
  116.         return bool(self._table.children)
  117.  
  118.     
  119.     def has_exec(self):
  120.         return bool(self._table.optimized & (OPT_EXEC | OPT_BARE_EXEC))
  121.  
  122.     
  123.     def has_import_star(self):
  124.         return bool(self._table.optimized & OPT_IMPORT_STAR)
  125.  
  126.     
  127.     def get_identifiers(self):
  128.         return self._table.symbols.keys()
  129.  
  130.     
  131.     def lookup(self, name):
  132.         sym = self._symbols.get(name)
  133.         if sym is None:
  134.             flags = self._table.symbols[name]
  135.             namespaces = self._SymbolTable__check_children(name)
  136.             sym = self._symbols[name] = Symbol(name, flags, namespaces)
  137.         
  138.         return sym
  139.  
  140.     
  141.     def get_symbols(self):
  142.         return [ self.lookup(ident) for ident in self.get_identifiers() ]
  143.  
  144.     
  145.     def __check_children(self, name):
  146.         return _[1]
  147.  
  148.     
  149.     def get_children(self):
  150.         return [ newSymbolTable(st, self._filename) for st in self._table.children ]
  151.  
  152.  
  153.  
  154. class Function(SymbolTable):
  155.     __params = None
  156.     __locals = None
  157.     __frees = None
  158.     __globals = None
  159.     
  160.     def __idents_matching(self, test_func):
  161.         return [](_[1])
  162.  
  163.     
  164.     def get_parameters(self):
  165.         if self._Function__params is None:
  166.             self._Function__params = self._Function__idents_matching((lambda x: x & DEF_PARAM))
  167.         
  168.         return self._Function__params
  169.  
  170.     
  171.     def get_locals(self):
  172.         if self._Function__locals is None:
  173.             self._Function__locals = self._Function__idents_matching((lambda x: x & DEF_BOUND))
  174.         
  175.         return self._Function__locals
  176.  
  177.     
  178.     def get_globals(self):
  179.         if self._Function__globals is None:
  180.             glob = DEF_GLOBAL | DEF_FREE_GLOBAL
  181.             self._Function__globals = (self._Function__idents_matching,)((lambda x: x & glob))
  182.         
  183.         return self._Function__globals
  184.  
  185.     
  186.     def get_frees(self):
  187.         if self._Function__frees is None:
  188.             self._Function__frees = self._Function__idents_matching(is_free)
  189.         
  190.         return self._Function__frees
  191.  
  192.  
  193.  
  194. class Class(SymbolTable):
  195.     __methods = None
  196.     
  197.     def get_methods(self):
  198.         if self._Class__methods is None:
  199.             d = { }
  200.             for st in self._table.children:
  201.                 d[st.name] = 1
  202.             
  203.             self._Class__methods = tuple(d)
  204.         
  205.         return self._Class__methods
  206.  
  207.  
  208.  
  209. class Symbol:
  210.     
  211.     def __init__(self, name, flags, namespaces = None):
  212.         self._Symbol__name = name
  213.         self._Symbol__flags = flags
  214.         if not namespaces:
  215.             pass
  216.         self._Symbol__namespaces = ()
  217.  
  218.     
  219.     def __repr__(self):
  220.         return "<symbol '%s'>" % self._Symbol__name
  221.  
  222.     
  223.     def get_name(self):
  224.         return self._Symbol__name
  225.  
  226.     
  227.     def is_referenced(self):
  228.         return bool(self._Symbol__flags & _symtable.USE)
  229.  
  230.     
  231.     def is_parameter(self):
  232.         return bool(self._Symbol__flags & DEF_PARAM)
  233.  
  234.     
  235.     def is_global(self):
  236.         if not self._Symbol__flags & DEF_GLOBAL:
  237.             pass
  238.         return bool(self._Symbol__flags & DEF_FREE_GLOBAL)
  239.  
  240.     
  241.     def is_vararg(self):
  242.         return bool(self._Symbol__flags & DEF_STAR)
  243.  
  244.     
  245.     def is_keywordarg(self):
  246.         return bool(self._Symbol__flags & DEF_DOUBLESTAR)
  247.  
  248.     
  249.     def is_local(self):
  250.         return bool(self._Symbol__flags & DEF_BOUND)
  251.  
  252.     
  253.     def is_free(self):
  254.         if self._Symbol__flags & (USE | DEF_FREE) and self._Symbol__flags & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL):
  255.             return True
  256.         
  257.         if self._Symbol__flags & DEF_FREE_CLASS:
  258.             return True
  259.         
  260.         return False
  261.  
  262.     
  263.     def is_imported(self):
  264.         return bool(self._Symbol__flags & DEF_IMPORT)
  265.  
  266.     
  267.     def is_assigned(self):
  268.         return bool(self._Symbol__flags & DEF_LOCAL)
  269.  
  270.     
  271.     def is_in_tuple(self):
  272.         return bool(self._Symbol__flags & DEF_INTUPLE)
  273.  
  274.     
  275.     def is_namespace(self):
  276.         return bool(self._Symbol__namespaces)
  277.  
  278.     
  279.     def get_namespaces(self):
  280.         return self._Symbol__namespaces
  281.  
  282.     
  283.     def get_namespace(self):
  284.         if len(self._Symbol__namespaces) != 1:
  285.             raise ValueError, 'name is bound to multiple namespaces'
  286.         
  287.         return self._Symbol__namespaces[0]
  288.  
  289.  
  290. if __name__ == '__main__':
  291.     import os
  292.     import sys
  293.     src = open(sys.argv[0]).read()
  294.     mod = symtable(src, os.path.split(sys.argv[0])[1], 'exec')
  295.     for ident in mod.get_identifiers():
  296.         info = mod.lookup(ident)
  297.         print info, info.is_local(), info.is_namespace()
  298.     
  299.  
  300.